package server.login;

import comun.login.*;
import server.aula.ControlAula;
import server.grupo.ControlConsultaGrupo;
import server.grupo.ControlGrupo;
import server.grupo.ControlParticipanteGrupo;
import persistencia.Persistencia;
import java.util.*;

import persistencia.dominio.*;
import comun.*;
import comun.constantes.*;
import utils.ManejoString;
import utils.Utils;
/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author unascribed
 * @version 1.0
 */

public class ControlLogin {
  private Persistencia persistencia = null;
  private boolean debug = false;
  private Long idAccesoPagina;
  public ControlLogin(Persistencia persistencia) {
    this.persistencia=persistencia;
  }

  // si la persona no exite retorna null
  public Persona getUsuario(BeansLogin beansLogin) throws Exception {
      // poner nombreUsuario y password en la consulta
      /*String filtro =
          "login == \""+beansLogin.getLogin()+
          "\" & password == \""+server.general.Util.encrypt(beansLogin.getClave())+"\"";*/
	  String nroSinPuntos = ManejoString.eliminarPuntosDelDocumento(beansLogin.getLogin());
	  String filtro = "";
	  String login = "( login == \""+beansLogin.getLogin()+"\"";
	  String dni = " | numeroDoc == \""+nroSinPuntos+"\"";
	  String correo = " | email == \""+beansLogin.getLogin()+"\"";
	  String password = ") & password == \""+server.general.Util.encrypt(beansLogin.getClave())+"\"";
      
	  Vector personas = null;
	  filtro = login+dni+correo+password;  
      personas = persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.Persona",filtro);
      if(personas.size()!=0)
        return (Persona)personas.elementAt(0);
      else return null;
  }


  /**
   * Si el usuario existe(informacion en beandLogin) retorna el id de la persona,
   * si no existe retorna null
   * @param beansLogin
   * @param ipAddrres
   * @return
   * @throws Exception
   */
  public Long login(BeansLogin beansLogin, String ipAddrres) throws Exception
  {
      Persona usuario = this.getUsuario(beansLogin);
        if (usuario!=null)
        {
          // login correcto debo registrar el acceso
          AccesoPagina accesoPagina = new AccesoPagina();
          accesoPagina.setFechaHoraEntrada(Utils.hoySqlDate());
          accesoPagina.setHost(ipAddrres);
          persistencia.hacerPersistente(accesoPagina);
          accesoPagina.setPersona(usuario);

          this.setIdAccesoPagina(accesoPagina.getId());
          return usuario.getId();
        }
        else
          return null;
  }

  
  
// retorna los objetos aulas relacionados con la persona(idPerosa)
  // utilizado para obtener los permisos
  private Vector getAulasUsuario(Long idPersona, boolean historial) throws Exception
  {
      // poner nombreUsuario y password en la consulta
      String filtroComun=
          "persona.id == "+idPersona;
      String filtro = "";
      // Armo filtro para obtener los cursos
      if (!historial)
        filtro = filtroComun+
        // necesito cartearlo a las subclases concretas del aula compuesta
        " & ( "+
        "      ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.EN_PREPARACION +"\" "+
        "    | ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.PRE_INSCRIPCION +"\" "+
        "    | ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.SELECCION +"\" "+
        "    | ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.ACTIVO +"\" "+
        " )";
      else
        filtro = filtroComun + " & ( ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.FINALIZADO +"\" "+
        " )";

      Vector cursos = persistencia.getObjectosPorClaseYFiltro
              ("persistencia.dominio.Participante",filtro);

      // Armo filtro para obtener las organizaciones
/*        if (!historial)
          filtro = filtroComun+
          // necesito cartearlo a las subclases concretas del aula compuesta
          " & ( "+
          "      ((Organizacion)aula).estadoAula.descripcion == \""+ESTADO_AULAS.EN_PREPARACION +"\" "+
          "    | ((Organizacion)aula).estadoAula.descripcion == \""+ESTADO_AULAS.PRE_INSCRIPCION +"\" "+
          "    | ((Organizacion)aula).estadoAula.descripcion == \""+ESTADO_AULAS.SELECCION +"\" "+
          "    | ((Organizacion)aula).estadoAula.descripcion == \""+ESTADO_AULAS.ACTIVO +"\" "+
          " )";
        else
      */

      // filtro para que traiga todas las organizaciones sin importar el estado
      filtro = filtroComun + " & ( ((Organizacion)aula).estadoAula.descripcion != \" \" "+
          " )";


        Vector organizaciones = persistencia.getObjectosPorClaseYFiltro
                ("persistencia.dominio.Participante",filtro);

        // Armo filtro para obtener las organizaciones
        filtro = filtroComun + " & ( ((Facultad)aula).estadoAula.descripcion != \" \" "+
            " )";


          Vector facultades = persistencia.getObjectosPorClaseYFiltro
                  ("persistencia.dominio.Participante",filtro);
          
          // creo un vector con todas los objetos de los subtipos de AulaCompuesta
          Vector aulas = new Vector();
          aulas.addAll(cursos);
          aulas.addAll(organizaciones);          
          aulas.addAll(facultades);
      return aulas;
  }


  /**
   * Retorna los link del campus
   * @param idCampus
   * @return
   */
  public Vector obtenerLinksCampus(Long idCampus)
  {
    try {
      return persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.Enlace","nombre","aula.id == "+idCampus);
    }
    catch (MyException ex) {
      return null;
    }
  }


/**
 *
 * @param idCampus
 * @param cantidadNoticias
 * @return
 */
 public Vector obtenerUltimasNoticias(Long idCampus,int cantidadNoticias)
 {
  try {
    Vector ultimasNoticias = new Vector();
     // obtengo el campus
     Organizacion campus = (Organizacion) persistencia.getObjectoPorId("persistencia.dominio.Organizacion",idCampus);

     String filtro=
         " comunicacion.id == "+campus.getNovedad().getId();

     Vector textos = persistencia.getObjectosPorClaseYFiltro
             ("persistencia.dominio.Texto","fecha descending",filtro);

     int noticia = 0;
     Enumeration enum = textos.elements();
     while (enum.hasMoreElements() & noticia<cantidadNoticias) {
       ultimasNoticias.addElement(enum.nextElement());
       noticia++;
     }
     return ultimasNoticias;
  }
  catch (MyException ex) {
    ex.printStackTrace();
    return new Vector();
  }

 }

 /**
  * obtiene el id del campus, asumimos que es uno solo
  * @return
  * @throws Exception
  */
 public Long obtenerIdCampus()
     throws Exception
 {
     String filtro=
         " tipoAula.nombre == \""+TIPO_AULAS.CAMPUS+"\"";

     Vector campus = persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.Organizacion","",filtro,"");
     if (campus.size()!=0)
       return ((Organizacion)campus.elementAt(0)).getId();
     return null;
 }


  /**
   * Obtiene los permisos para cada recurso que tiene el usuario en
   * todas las aulas en que participa
   *
   * @param beansLogin
   * @return
   */
  public Hashtable obtenerPermisosUsuario(Long idPersona, boolean historial) throws Exception
  {
      Hashtable hashtablePermisosRecursosPorAula = new Hashtable();
      // obtengo los participantes
      Vector participantes = getAulasUsuario(idPersona, historial);
      Aula aula = null;
      TipoUsuario tipoUsuario = null;

      // recorro los partipantes para obtener los permisos de acuerso al tipo de usuario
      Enumeration enum = participantes.elements();
      while (enum.hasMoreElements()) {

        Participante participante = (Participante) enum.nextElement();
        tipoUsuario = participante.getTipoUsuario();

        //if (debug) System.out.println("participante: "+participante.getPersona().getNombreYApellido());
        //if (debug) System.out.println("participante: "+participante.getId());
        Vector aulas = new Vector();
        aulas.addElement(participante.getAula());
        // obtengo la comisiones en que esta inscripto la persona
        Iterator enum1 = participante.getParticipanteComisiones().iterator();
        while (enum1.hasNext()) {
          Aula comision = ((ParticipanteComision)enum1.next()).getComision();
          aulas.addElement(comision);
          //if (debug) System.out.println("comisiones:"+comision);
        }

        //recorro las aula, Aula y comisiones
        Enumeration enumAulas = aulas.elements();
        while (enumAulas.hasMoreElements()) {
          aula = (Aula)enumAulas.nextElement();
          //if (debug) System.out.println("");
/*          System.out.println("OBTENIENDO PERMISO AULA: "+aula.getNombre());
          if (debug)   System.out.println("OBTENIENDO PERMISO AULA aula.getId(): "+aula.getId());
          if (debug)   System.out.println("OBTENIENDO PERMISO AULA tipoUsuario.getId(): "+tipoUsuario.getId());
          */
          //if (debug)   System.out.println("aula:"+aula);
          //if (debug)   System.out.println("aula:"+aula.getNombre());

          // controlo que ya esten cargados los permisos para el aula,
          // puede ocurrir que una misma persona tenga mas de un objeto particiipante por curso
          // el caso se da por ej.: cuando es tutor y administrador al mismo tiempo,
          // en estos casos se hace una fusion de permisos, quedando el mas alto permiso por recurso
          Hashtable hashtablePermisosPorRecurso = (Hashtable)hashtablePermisosRecursosPorAula.get(aula.getId());
          if (hashtablePermisosPorRecurso == null)
            hashtablePermisosPorRecurso = new Hashtable();

//          if (debug)   System.out.println("Aula: "+enum.nextElement());
//          if (debug)   System.out.println("Aula: "+aula);
          String filtro=
              "aula.id == "+aula.getId();
          tipoUsuario = participante.getTipoUsuario();
          filtro += " & tipoUsuario.id == "+tipoUsuario.getId();
           
          Vector permisosAccesos = persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.PermisoAcceso",filtro);

          //recorre todos los permisos accesos para llenar la tabla de hash de permisos
          Enumeration enumPermisos = permisosAccesos.elements();
          while (enumPermisos.hasMoreElements()) {
            PermisoAcceso permisoAcceso = (PermisoAcceso)enumPermisos.nextElement();
            // pongo el nombre del recurso y la descripcion del tipo de permiso
            // para que sea mas practico el manejo que con los Id
            //if (debug)   System.out.println("");
            //if (debug)   System.out.print("Aula: "+aula.getId()+" - "+aula.getNombre());
            //if (debug)   System.out.println("#######--->"+permisoAcceso+" -- id:"+permisoAcceso.getId());
            //if (debug)   System.out.print("  -- recurso: "+permisoAcceso.getRecurso());
            //if (debug)   System.out.print("  -- recurso: "+permisoAcceso.getRecurso().getNombre()+" - "+aula.getNombre());
            //if (debug)   System.out.print("  -- TipoPermiso: "+permisoAcceso.getTipoPermiso().getDescripcion());

            // controlo que tenga un permiso anterior, por otro tipo de usuario que pudiera tener la persona
            // en el curso, se debe quedar con el maximo permiso para el recurso
                hashtablePermisosPorRecurso.put(
                    permisoAcceso.getRecurso().getNombre(),
                    TIPO_PERMISOS.maximoPermiso(
                           (String)hashtablePermisosPorRecurso.get(permisoAcceso.getRecurso().getNombre()),
                           permisoAcceso.getTipoPermiso().getDescripcion())
                           );


/*            hashtablePermisosPorRecurso.put(
                permisoAcceso.getRecurso().getNombre(),
                permisoAcceso.getTipoPermiso().getDescripcion());
  */
          }
          // agrego la entrada a la tabla de hash correspondiente al aula
          hashtablePermisosRecursosPorAula.put(aula.getId(),hashtablePermisosPorRecurso);
        }

    } // fin del recorrido de las aulas(y comisiones) por participante           
      return hashtablePermisosRecursosPorAula;
    }
    
  public void setIdAccesoPagina(Long idAccesoPagina) {
    this.idAccesoPagina = idAccesoPagina;
  }
  public Long getIdAccesoPagina() {
    return idAccesoPagina;
  }

  /*CODIGO AGREGADO POR GRUPO CONDE-PEREYRA - TEMA: GRUPOS*/
  public Hashtable obtenerNomenclaturas(Long idPersona, boolean historial) throws Exception{
	  Hashtable hashtableNomenclaturasPorAula = new Hashtable();
	  Vector participantes = getSoloParticipantesAulasUsuario(idPersona, historial);
	  Aula aula = null;
      Enumeration enum = participantes.elements();
      String filtro=""; 
      while (enum.hasMoreElements()) {
        Participante participante = (Participante) enum.nextElement();
        aula = participante.getAula();
        filtro = "aula.id == "+aula.getId();
        filtro += " & nomenclaturaSingular != null"; 
        Vector nomenclaturas = persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.AulaTipoUsuario",filtro);
        if(!nomenclaturas.isEmpty()){
        	Enumeration enumNumenclaturas = nomenclaturas.elements();
        	Hashtable hashtableDelAula = (Hashtable)hashtableNomenclaturasPorAula.get(aula.getId());
	        if (hashtableDelAula == null) hashtableDelAula = new Hashtable();
	        while (enumNumenclaturas.hasMoreElements()) {
	        	AulaTipoUsuario corriente = (AulaTipoUsuario)enumNumenclaturas.nextElement();
	            hashtableDelAula.put(corriente.getTipoUsuario().getNombre(),corriente.getNomenclaturaSingular());
	            hashtableDelAula.put(corriente.getTipoUsuario().getNombre()+"plu",corriente.getNomenclaturaPlural());
	        }
	        hashtableNomenclaturasPorAula.put(aula.getId(),hashtableDelAula);
        }    
      }  
	  return hashtableNomenclaturasPorAula;
  }
  
  /*Esta contemplado para Organizaciones y Aulas. En caso de que se quiera usar para comisiones y grupos. Habria que
   *obtener los logos por medio de objeto participante comision.*/
  public Hashtable obtenerLogos(Long idPersona, boolean historial) throws Exception{
	  Hashtable hashtableLogosDeAula = new Hashtable();
	  Vector participantes = getSoloParticipantesAulasUsuario(idPersona, historial);
      Enumeration enum = participantes.elements();      
      while (enum.hasMoreElements()) {
        Participante participante = (Participante) enum.nextElement();
        AulaCompuesta aula = ((AulaCompuesta)participante.getAula());
        //System.out.println("Nombre Aula: "+aula.getNombre()); 
        //El aula u organizacion tiene su logo particular 
        if(aula.getPathLogo()!= null && aula.getPathLogo().compareTo("")!=0){        	
           	hashtableLogosDeAula.put(aula.getId(),aula.getPathLogo());       
           	//Inserto el path del logo en las sub aulas. 
           	for (Iterator j = aula.getAulas().iterator(); j.hasNext();) {
				Aula subAula = (Aula) j.next();
				//System.out.println("Nombre SubAula 1: "+subAula.getNombre());
				hashtableLogosDeAula.put(subAula.getId(),aula.getPathLogo());				
			}
        }else{
        //El aula no tiene su logo particular, pero puede que la organizacion si. Entonces tenga cargado en la
        //hashtable ya el logo que esta aula debe seguir mostrando. Entonces debemos obtener ese path de la hash y 
        //seguir poniendolo en las sub aulas.	
        	if(hashtableLogosDeAula.get(aula.getId())!= null && ((String)hashtableLogosDeAula.get(aula.getId())).compareTo("")!=0)
        		for (Iterator j = aula.getAulas().iterator(); j.hasNext();) {
    				Aula subAula = (Aula) j.next();
    				//System.out.println("Nombre SubAula 2: "+subAula.getNombre());
    				hashtableLogosDeAula.put(subAula.getId(),(String)hashtableLogosDeAula.get(aula.getId()));								
    		}        		
        }        	
      }  
      
      /*Cargamos las aulas publicas para mostrar otro banner*/
      Vector publicas = getAulasPublicas();
      Enumeration enum2 = publicas.elements();      
      while (enum2.hasMoreElements()) {
    	  Curso curso = (Curso) enum2.nextElement();
    	  if(curso.getPathLogo()!= null && curso.getPathLogo().compareTo("")!=0){        	
           	hashtableLogosDeAula.put(curso.getId(),curso.getPathLogo());       
           	//Inserto el path del logo en las sub aulas. 
           	for (Iterator j = curso.getAulas().iterator(); j.hasNext();) {
				Aula subAula = (Aula) j.next();
				//System.out.println("Nombre SubAula 1: "+subAula.getNombre());
				hashtableLogosDeAula.put(subAula.getId(),curso.getPathLogo());				
			}
        }
      }  
	  return hashtableLogosDeAula;
  }
  
  public Vector getAulasPublicas() throws Exception {
		String filtro =  "tipoAcceso == \""+TIPO_ACCESO_AULA.PUBLICO+"\"";
		filtro +=
			" & ( estadoAula.descripcion == \""+ESTADO_AULAS.EN_PREPARACION +"\" "+
			"    | estadoAula.descripcion == \""+ESTADO_AULAS.PRE_INSCRIPCION +"\" "+
			"    | estadoAula.descripcion == \""+ESTADO_AULAS.SELECCION +"\" "+
			"    | estadoAula.descripcion == \""+ESTADO_AULAS.ACTIVO +"\" )";
		Vector cursos = this.persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.Curso","nombre",filtro);
		return cursos;
	}
  
  public Hashtable obtenerFavoritas(Long idPersona, boolean historial) throws Exception{
	  Hashtable hashtableAulasFavoritas = new Hashtable();
	  String filtroComun=
		  "persona.id == "+idPersona;
	  String filtro = "";
	  // Armo filtro para obtener los cursos
	  if (!historial)
		  filtro = filtroComun+
		  // necesito cartearlo a las subclases concretas del aula compuesta
		  " & ( "+
		  "      ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.EN_PREPARACION +"\" "+
		  "    | ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.PRE_INSCRIPCION +"\" "+
		  "    | ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.SELECCION +"\" "+
		  "    | ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.ACTIVO +"\" "+
		  " )";
	  else
		  filtro = filtroComun + " & ( ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.FINALIZADO +"\" "+
		  " )";
	  Vector cursos = persistencia.getObjectosPorClaseYFiltro
	  		("persistencia.dominio.Favorito",filtro);
	  for (Iterator iter = cursos.iterator(); iter.hasNext();) {
		Favorito favorito = (Favorito) iter.next();
		hashtableAulasFavoritas.put(favorito.getAula().getId(),favorito.getAula().getNombre());
	}
	  return hashtableAulasFavoritas;
  }
  
  public Hashtable obtenerPermisosUsuarioGrupo(Long idPersona, Long idAula) throws Exception{
   	  Hashtable hashtablePermisosDelGrupo = null;
      Hashtable hashtablePermisosRecursosDeLosGrupos = new Hashtable();
      hashtablePermisosRecursosDeLosGrupos.put(PARAMETROS_PAGINAS.ID_AULA,idAula);
      Participante participante = null;
      ControlParticipanteGrupo controlParticipanteGrupo = new ControlParticipanteGrupo(persistencia);
      ControlConsultaGrupo controlConsultaGrupo = new ControlConsultaGrupo(persistencia);
      ControlGrupo controlGrupo = new ControlGrupo(persistencia);
      ControlAula controlAula = new ControlAula(persistencia);
      Vector participes = controlAula.getParticipantes(idAula,idPersona);//Obtenemos todos lo objetos participantes de la persona en el aula...
      Grupo grupo = null;
      TipoUsuario tipoUsuario = null;
      Vector grupos = new Vector();
      Vector gruposSinPartic = null;
      String filtro = null;
      String permi = null;
      Enumeration enumGrupos = null;
      Enumeration enumPermisos = null;
      for (Iterator iterador = participes.iterator(); iterador.hasNext();) {
    	  participante = (Participante) iterador.next();
    	  //participante = ((Participante)controlAula.getParticipante(idAula,idPersona));
	      tipoUsuario = participante.getTipoUsuario();
	      if(tipoUsuario.getNombre().compareTo(TIPO_USUARIOS.ALUMNO)==0){
	    	  //Los alumnos solo ven los grupos visibles del Aula, es al pedo cargar todo
	    	  grupos = controlConsultaGrupo.getGruposDelAula(idAula,ESTADO_GRUPOS.SOLO_VISIBLE,false);
	    	  grupos.addAll(controlGrupo.getGruposSinParticipantes(idAula,ESTADO_GRUPOS.SOLO_VISIBLE,null));
	    	  Comision comision = (Comision)(controlAula.getComisionesPersona(idAula, idPersona)).firstElement();
	    	  grupos.addAll(controlGrupo.getGruposSinParticipantes(comision.getId(),ESTADO_GRUPOS.SOLO_VISIBLE,null));
	    	  grupos.addAll(controlParticipanteGrupo.getGruposDelParticipanteEnEstado(participante.getId(), ESTADO_GRUPOS.FINALIZADO));
	    	  enumGrupos = grupos.elements();
	    	  boolean buscarPermisos = true;
	    	  while (enumGrupos.hasMoreElements()) {
	              grupo = (Grupo)enumGrupos.nextElement();
	              if(controlParticipanteGrupo.personaEsIntegranteDelGrupo(grupo.getId(), idPersona)){
		           	  tipoUsuario = controlAula.getParticipanteComision(grupo.getId(), idPersona).getTipoUsuario();
		           	  buscarPermisos = true;
	              }else{
		              if(grupo.getTipoGrupo().getDescripcion().compareTo(TIPO_GRUPOS.PUBLICO)==0){
		            	  tipoUsuario = (TipoUsuario)persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.TipoUsuario","nombre==\""+TIPO_USUARIOS.USUARIO_PUBLICO+"\" ").elementAt(0);
		              	  buscarPermisos = true;
		              }	  
		          }
	              if(buscarPermisos){
	            	  hashtablePermisosDelGrupo = (Hashtable)hashtablePermisosRecursosDeLosGrupos.get(grupo.getId());
	            	  if (hashtablePermisosDelGrupo == null)
	            		  hashtablePermisosDelGrupo = new Hashtable();
		              filtro = "aula.id == "+grupo.getId();
		              filtro += " & tipoUsuario.id == "+tipoUsuario.getId();
		        	  Vector permisosAccesos = persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.PermisoAcceso",filtro);
		        	  enumPermisos = permisosAccesos.elements();
		        	  if(grupo.getEstadoGrupo().getDescripcion().compareTo(ESTADO_GRUPOS.FINALIZADO)==0){
		        		  //Debemos cargar Permisos solo Lectura	
			        	  while (enumPermisos.hasMoreElements()) {
			        		  PermisoAcceso permisoAcceso = (PermisoAcceso)enumPermisos.nextElement();
			        		  permi = TIPO_PERMISOS.maximoPermiso((String)hashtablePermisosDelGrupo.get(permisoAcceso.getRecurso().getNombre()),
	        						  permisoAcceso.getTipoPermiso().getDescripcion());	        	
			        		  if(permi.compareTo(TIPO_PERMISOS.ESCRITURA)==0)
									permi = TIPO_PERMISOS.LECTURA;
			        		  hashtablePermisosDelGrupo.put(permisoAcceso.getRecurso().getNombre(),permi);
			        	  }
		        	  }else{
		        		  while (enumPermisos.hasMoreElements()) {
			        		  PermisoAcceso permisoAcceso = (PermisoAcceso)enumPermisos.nextElement();
			        		  hashtablePermisosDelGrupo.put(
			        				  permisoAcceso.getRecurso().getNombre(),
			        				  TIPO_PERMISOS.maximoPermiso(
			        						  (String)hashtablePermisosDelGrupo.get(permisoAcceso.getRecurso().getNombre()),
			        						  permisoAcceso.getTipoPermiso().getDescripcion())
			                          );
			        	  }
		        	  }
		              //agrego la entrada a la tabla de hash correspondiente al grupo
		              hashtablePermisosRecursosDeLosGrupos.put(grupo.getId(),hashtablePermisosDelGrupo);  
	              }	  
	    	  }    
	      }else{
	    	  //Porque el Docente (o mas rango) necesita ver todos los grupos
	    	  grupos = controlConsultaGrupo.getGruposDelAula(idAula);
	    	  gruposSinPartic = controlGrupo.getGruposSinParticipantes(idAula,false);
	    	  gruposSinPartic.addAll(controlGrupo.getGruposSinParticipantes(idAula,ESTADO_GRUPOS.BORRADOR,null));
	          Vector comisiones = controlAula.getComisionesDelAula(idAula);
	          for (Iterator i = comisiones.iterator(); i.hasNext();) {
	 			Comision comision = (Comision) i.next();
	 		   	gruposSinPartic.addAll(controlGrupo.getGruposSinParticipantes(comision.getId(),false));
	 		   	gruposSinPartic.addAll(controlGrupo.getGruposSinParticipantes(comision.getId(),ESTADO_GRUPOS.BORRADOR,null));
	          }
	          grupos.addAll(gruposSinPartic);
	    	  grupos.addAll(controlConsultaGrupo.getGruposDelAula(idAula,ESTADO_GRUPOS.ELIMINADO,false));
	    	  
	    	  enumGrupos = grupos.elements();
	    	  //System.out.println("================================================================================");
	    	  while (enumGrupos.hasMoreElements()) {
	              grupo = (Grupo)enumGrupos.nextElement();
	              hashtablePermisosDelGrupo = (Hashtable)hashtablePermisosRecursosDeLosGrupos.get(grupo.getId());
	              if (hashtablePermisosDelGrupo == null)
	            	  hashtablePermisosDelGrupo = new Hashtable();
	              filtro = "aula.id == "+grupo.getId();
	              filtro += " & tipoUsuario.id == "+tipoUsuario.getId();
	        	  Vector permisosAccesos = persistencia.getObjectosPorClaseYFiltro("persistencia.dominio.PermisoAcceso",filtro);
	        	  enumPermisos = permisosAccesos.elements();
	        	  if((grupo.getEstadoGrupo().getDescripcion().compareTo(ESTADO_GRUPOS.FINALIZADO)==0)||
	        			  (grupo.getEstadoGrupo().getDescripcion().compareTo(ESTADO_GRUPOS.ELIMINADO)==0)){
	        		  //Debemos cargar Permisos solo Lectura	
		        	  while (enumPermisos.hasMoreElements()) {
		        		  PermisoAcceso permisoAcceso = (PermisoAcceso)enumPermisos.nextElement();
		        		  permi = TIPO_PERMISOS.maximoPermiso((String)hashtablePermisosDelGrupo.get(permisoAcceso.getRecurso().getNombre()),
	    						  permisoAcceso.getTipoPermiso().getDescripcion());	        	
		        		  if(permi.compareTo(TIPO_PERMISOS.ESCRITURA)==0)
								permi = TIPO_PERMISOS.LECTURA;
		        		  hashtablePermisosDelGrupo.put(permisoAcceso.getRecurso().getNombre(),permi);
		        	  }
	        	  }else{
	        		  while (enumPermisos.hasMoreElements()) {
		        		  PermisoAcceso permisoAcceso = (PermisoAcceso)enumPermisos.nextElement();
		        		  hashtablePermisosDelGrupo.put(
		        				  permisoAcceso.getRecurso().getNombre(),
		        				  TIPO_PERMISOS.maximoPermiso(
		        						  (String)hashtablePermisosDelGrupo.get(permisoAcceso.getRecurso().getNombre()),
		        						  permisoAcceso.getTipoPermiso().getDescripcion())
		                          );
		        	  }
	        	  }
	              //agrego la entrada a la tabla de hash correspondiente al grupo
	              hashtablePermisosRecursosDeLosGrupos.put(grupo.getId(),hashtablePermisosDelGrupo);
	              //System.out.println("grupo.getNombre(): ->"+grupo.getNombre());
	    	  }
	    	  //System.out.println("================================================================================");
	      }
      }    
      return hashtablePermisosRecursosDeLosGrupos;
  }
  
//retorna los objetos aulas relacionados con la persona(idPerosa)
  // utilizado para obtener los permisos
  private Vector getSoloParticipantesAulasUsuario(Long idPersona, boolean historial) throws Exception
  {
		  // poner nombreUsuario y password en la consulta
		  String filtroComun=
			  "persona.id == "+idPersona;
		  String filtro = "";
		  // Armo filtro para obtener los cursos
		  if (!historial)
			  filtro = filtroComun+
			  // necesito cartearlo a las subclases concretas del aula compuesta
			  " & ( "+
			  "      ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.EN_PREPARACION +"\" "+
			  "    | ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.PRE_INSCRIPCION +"\" "+
			  "    | ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.SELECCION +"\" "+
			  "    | ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.ACTIVO +"\" "+
			  " )";
		  else
			  filtro = filtroComun + " & ( ((Curso)aula).estadoAula.descripcion == \""+ESTADO_AULAS.FINALIZADO +"\" "+
			  " )";
		  Vector cursos = persistencia.getObjectosPorClaseYFiltro
		  		("persistencia.dominio.Participante",filtro);
		  //filtro para que traiga todas las organizaciones sin importar el estado
	      filtro = filtroComun + " & ( ((Organizacion)aula).estadoAula.descripcion != \" \" "+
	          " )";
	      Vector organizaciones = persistencia.getObjectosPorClaseYFiltro
	            ("persistencia.dominio.Participante",filtro);
          Vector aulas = new Vector();          
          aulas.addAll(organizaciones);
          aulas.addAll(cursos);
		  return aulas;
	 }
  /*HASTA ACA*/
}
